home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / command / sdist.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  15KB  |  376 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """distutils.command.sdist
  5.  
  6. Implements the Distutils 'sdist' command (create a source distribution)."""
  7. __revision__ = '$Id: sdist.py,v 1.59 2004/11/10 22:23:15 loewis Exp $'
  8. import sys
  9. import os
  10. import string
  11. from types import *
  12. from glob import glob
  13. from distutils.core import Command
  14. from distutils import dir_util, dep_util, file_util, archive_util
  15. from distutils.text_file import TextFile
  16. from distutils.errors import *
  17. from distutils.filelist import FileList
  18. from distutils import log
  19.  
  20. def show_formats():
  21.     '''Print all possible values for the \'formats\' option (used by
  22.     the "--help-formats" command-line option).
  23.     '''
  24.     FancyGetopt = FancyGetopt
  25.     import distutils.fancy_getopt
  26.     ARCHIVE_FORMATS = ARCHIVE_FORMATS
  27.     import distutils.archive_util
  28.     formats = []
  29.     for format in ARCHIVE_FORMATS.keys():
  30.         formats.append(('formats=' + format, None, ARCHIVE_FORMATS[format][2]))
  31.     
  32.     formats.sort()
  33.     pretty_printer = FancyGetopt(formats)
  34.     pretty_printer.print_help('List of available source distribution formats:')
  35.  
  36.  
  37. class sdist(Command):
  38.     description = 'create a source distribution (tarball, zip file, etc.)'
  39.     user_options = [
  40.         ('template=', 't', 'name of manifest template file [default: MANIFEST.in]'),
  41.         ('manifest=', 'm', 'name of manifest file [default: MANIFEST]'),
  42.         ('use-defaults', None, 'include the default file set in the manifest [default; disable with --no-defaults]'),
  43.         ('no-defaults', None, "don't include the default file set"),
  44.         ('prune', None, 'specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune]'),
  45.         ('no-prune', None, "don't automatically exclude anything"),
  46.         ('manifest-only', 'o', 'just regenerate the manifest and then stop (implies --force-manifest)'),
  47.         ('force-manifest', 'f', 'forcibly regenerate the manifest and carry on as usual'),
  48.         ('formats=', None, 'formats for source distribution (comma-separated list)'),
  49.         ('keep-temp', 'k', 'keep the distribution tree around after creating ' + 'archive file(s)'),
  50.         ('dist-dir=', 'd', 'directory to put the source distribution archive(s) in [default: dist]')]
  51.     boolean_options = [
  52.         'use-defaults',
  53.         'prune',
  54.         'manifest-only',
  55.         'force-manifest',
  56.         'keep-temp']
  57.     help_options = [
  58.         ('help-formats', None, 'list available distribution formats', show_formats)]
  59.     negative_opt = {
  60.         'no-defaults': 'use-defaults',
  61.         'no-prune': 'prune' }
  62.     default_format = {
  63.         'posix': 'gztar',
  64.         'nt': 'zip' }
  65.     
  66.     def initialize_options(self):
  67.         self.template = None
  68.         self.manifest = None
  69.         self.use_defaults = 1
  70.         self.prune = 1
  71.         self.manifest_only = 0
  72.         self.force_manifest = 0
  73.         self.formats = None
  74.         self.keep_temp = 0
  75.         self.dist_dir = None
  76.         self.archive_files = None
  77.  
  78.     
  79.     def finalize_options(self):
  80.         if self.manifest is None:
  81.             self.manifest = 'MANIFEST'
  82.         
  83.         if self.template is None:
  84.             self.template = 'MANIFEST.in'
  85.         
  86.         self.ensure_string_list('formats')
  87.         if self.formats is None:
  88.             
  89.             try:
  90.                 self.formats = [
  91.                     self.default_format[os.name]]
  92.             except KeyError:
  93.                 raise DistutilsPlatformError, "don't know how to create source distributions " + 'on platform %s' % os.name
  94.             except:
  95.                 None<EXCEPTION MATCH>KeyError
  96.             
  97.  
  98.         None<EXCEPTION MATCH>KeyError
  99.         bad_format = archive_util.check_archive_formats(self.formats)
  100.         if bad_format:
  101.             raise DistutilsOptionError, "unknown archive format '%s'" % bad_format
  102.         
  103.         if self.dist_dir is None:
  104.             self.dist_dir = 'dist'
  105.         
  106.  
  107.     
  108.     def run(self):
  109.         self.filelist = FileList()
  110.         self.check_metadata()
  111.         self.get_file_list()
  112.         if self.manifest_only:
  113.             return None
  114.         
  115.         self.make_distribution()
  116.  
  117.     
  118.     def check_metadata(self):
  119.         '''Ensure that all required elements of meta-data (name, version,
  120.         URL, (author and author_email) or (maintainer and
  121.         maintainer_email)) are supplied by the Distribution object; warn if
  122.         any are missing.
  123.         '''
  124.         metadata = self.distribution.metadata
  125.         missing = []
  126.         for attr in ('name', 'version', 'url'):
  127.             if not hasattr(metadata, attr) and getattr(metadata, attr):
  128.                 missing.append(attr)
  129.                 continue
  130.         
  131.         if missing:
  132.             self.warn('missing required meta-data: ' + string.join(missing, ', '))
  133.         
  134.         if metadata.author:
  135.             if not metadata.author_email:
  136.                 self.warn("missing meta-data: if 'author' supplied, " + "'author_email' must be supplied too")
  137.             
  138.         elif metadata.maintainer:
  139.             if not metadata.maintainer_email:
  140.                 self.warn("missing meta-data: if 'maintainer' supplied, " + "'maintainer_email' must be supplied too")
  141.             
  142.         else:
  143.             self.warn('missing meta-data: either (author and author_email) ' + 'or (maintainer and maintainer_email) ' + 'must be supplied')
  144.  
  145.     
  146.     def get_file_list(self):
  147.         """Figure out the list of files to include in the source
  148.         distribution, and put it in 'self.filelist'.  This might involve
  149.         reading the manifest template (and writing the manifest), or just
  150.         reading the manifest, or just using the default file set -- it all
  151.         depends on the user's options and the state of the filesystem.
  152.         """
  153.         template_exists = os.path.isfile(self.template)
  154.         if template_exists:
  155.             template_newer = dep_util.newer(self.template, self.manifest)
  156.         
  157.         self.debug_print('checking if %s newer than %s' % (self.distribution.script_name, self.manifest))
  158.         setup_newer = dep_util.newer(self.distribution.script_name, self.manifest)
  159.         if not template_exists and template_newer:
  160.             pass
  161.         manifest_outofdate = setup_newer
  162.         if not self.force_manifest:
  163.             pass
  164.         force_regen = self.manifest_only
  165.         manifest_exists = os.path.isfile(self.manifest)
  166.         if not template_exists:
  167.             pass
  168.         neither_exists = not manifest_exists
  169.         if manifest_outofdate and neither_exists or force_regen:
  170.             if not template_exists:
  171.                 self.warn(("manifest template '%s' does not exist " + '(using default file list)') % self.template)
  172.             
  173.             self.filelist.findall()
  174.             if self.use_defaults:
  175.                 self.add_defaults()
  176.             
  177.             if template_exists:
  178.                 self.read_template()
  179.             
  180.             if self.prune:
  181.                 self.prune_file_list()
  182.             
  183.             self.filelist.sort()
  184.             self.filelist.remove_duplicates()
  185.             self.write_manifest()
  186.         else:
  187.             self.read_manifest()
  188.  
  189.     
  190.     def add_defaults(self):
  191.         """Add all the default files to self.filelist:
  192.           - README or README.txt
  193.           - setup.py
  194.           - test/test*.py
  195.           - all pure Python modules mentioned in setup script
  196.           - all C sources listed as part of extensions or C libraries
  197.             in the setup script (doesn't catch C headers!)
  198.         Warns if (README or README.txt) or setup.py are missing; everything
  199.         else is optional.
  200.         """
  201.         standards = [
  202.             ('README', 'README.txt'),
  203.             self.distribution.script_name]
  204.         for fn in standards:
  205.             if type(fn) is TupleType:
  206.                 alts = fn
  207.                 got_it = 0
  208.                 for fn in alts:
  209.                     if os.path.exists(fn):
  210.                         got_it = 1
  211.                         self.filelist.append(fn)
  212.                         break
  213.                         continue
  214.                 
  215.                 if not got_it:
  216.                     self.warn('standard file not found: should have one of ' + string.join(alts, ', '))
  217.                 
  218.             got_it
  219.             if os.path.exists(fn):
  220.                 self.filelist.append(fn)
  221.                 continue
  222.             self.warn("standard file '%s' not found" % fn)
  223.         
  224.         optional = [
  225.             'test/test*.py',
  226.             'setup.cfg']
  227.         for pattern in optional:
  228.             files = filter(os.path.isfile, glob(pattern))
  229.             if files:
  230.                 self.filelist.extend(files)
  231.                 continue
  232.         
  233.         if self.distribution.has_pure_modules():
  234.             build_py = self.get_finalized_command('build_py')
  235.             self.filelist.extend(build_py.get_source_files())
  236.         
  237.         if self.distribution.has_ext_modules():
  238.             build_ext = self.get_finalized_command('build_ext')
  239.             self.filelist.extend(build_ext.get_source_files())
  240.         
  241.         if self.distribution.has_c_libraries():
  242.             build_clib = self.get_finalized_command('build_clib')
  243.             self.filelist.extend(build_clib.get_source_files())
  244.         
  245.         if self.distribution.has_scripts():
  246.             build_scripts = self.get_finalized_command('build_scripts')
  247.             self.filelist.extend(build_scripts.get_source_files())
  248.         
  249.  
  250.     
  251.     def read_template(self):
  252.         '''Read and parse manifest template file named by self.template.
  253.  
  254.         (usually "MANIFEST.in") The parsing and processing is done by
  255.         \'self.filelist\', which updates itself accordingly.
  256.         '''
  257.         log.info("reading manifest template '%s'", self.template)
  258.         template = TextFile(self.template, strip_comments = 1, skip_blanks = 1, join_lines = 1, lstrip_ws = 1, rstrip_ws = 1, collapse_join = 1)
  259.         while None:
  260.             line = template.readline()
  261.             if line is None:
  262.                 break
  263.             
  264.             
  265.             try:
  266.                 self.filelist.process_template_line(line)
  267.             continue
  268.             except DistutilsTemplateError:
  269.                 msg = None
  270.                 self.warn('%s, line %d: %s' % (template.filename, template.current_line, msg))
  271.                 continue
  272.             
  273.  
  274.  
  275.     
  276.     def prune_file_list(self):
  277.         '''Prune off branches that might slip into the file list as created
  278.         by \'read_template()\', but really don\'t belong there:
  279.           * the build tree (typically "build")
  280.           * the release tree itself (only an issue if we ran "sdist"
  281.             previously with --keep-temp, or it aborted)
  282.           * any RCS, CVS and .svn directories
  283.         '''
  284.         build = self.get_finalized_command('build')
  285.         base_dir = self.distribution.get_fullname()
  286.         self.filelist.exclude_pattern(None, prefix = build.build_base)
  287.         self.filelist.exclude_pattern(None, prefix = base_dir)
  288.         self.filelist.exclude_pattern('/(RCS|CVS|\\.svn)/.*', is_regex = 1)
  289.  
  290.     
  291.     def write_manifest(self):
  292.         """Write the file list in 'self.filelist' (presumably as filled in
  293.         by 'add_defaults()' and 'read_template()') to the manifest file
  294.         named by 'self.manifest'.
  295.         """
  296.         self.execute(file_util.write_file, (self.manifest, self.filelist.files), "writing manifest file '%s'" % self.manifest)
  297.  
  298.     
  299.     def read_manifest(self):
  300.         """Read the manifest file (named by 'self.manifest') and use it to
  301.         fill in 'self.filelist', the list of files to include in the source
  302.         distribution.
  303.         """
  304.         log.info("reading manifest file '%s'", self.manifest)
  305.         manifest = open(self.manifest)
  306.         while None:
  307.             line = manifest.readline()
  308.             if line == '':
  309.                 break
  310.             
  311.             if line[-1] == '\n':
  312.                 line = line[0:-1]
  313.             
  314.  
  315.     
  316.     def make_release_tree(self, base_dir, files):
  317.         """Create the directory tree that will become the source
  318.         distribution archive.  All directories implied by the filenames in
  319.         'files' are created under 'base_dir', and then we hard link or copy
  320.         (if hard linking is unavailable) those files into place.
  321.         Essentially, this duplicates the developer's source tree, but in a
  322.         directory named after the distribution, containing only the files
  323.         to be distributed.
  324.         """
  325.         self.mkpath(base_dir)
  326.         dir_util.create_tree(base_dir, files, dry_run = self.dry_run)
  327.         if hasattr(os, 'link'):
  328.             link = 'hard'
  329.             msg = 'making hard links in %s...' % base_dir
  330.         else:
  331.             link = None
  332.             msg = 'copying files to %s...' % base_dir
  333.         if not files:
  334.             log.warn('no files to distribute -- empty manifest?')
  335.         else:
  336.             log.info(msg)
  337.         for file in files:
  338.             if not os.path.isfile(file):
  339.                 log.warn("'%s' not a regular file -- skipping" % file)
  340.                 continue
  341.             dest = os.path.join(base_dir, file)
  342.             self.copy_file(file, dest, link = link)
  343.         
  344.         self.distribution.metadata.write_pkg_info(base_dir)
  345.  
  346.     
  347.     def make_distribution(self):
  348.         """Create the source distribution(s).  First, we create the release
  349.         tree with 'make_release_tree()'; then, we create all required
  350.         archive files (according to 'self.formats') from the release tree.
  351.         Finally, we clean up by blowing away the release tree (unless
  352.         'self.keep_temp' is true).  The list of archive files created is
  353.         stored so it can be retrieved later by 'get_archive_files()'.
  354.         """
  355.         base_dir = self.distribution.get_fullname()
  356.         base_name = os.path.join(self.dist_dir, base_dir)
  357.         self.make_release_tree(base_dir, self.filelist.files)
  358.         archive_files = []
  359.         for fmt in self.formats:
  360.             file = self.make_archive(base_name, fmt, base_dir = base_dir)
  361.             archive_files.append(file)
  362.         
  363.         self.archive_files = archive_files
  364.         if not self.keep_temp:
  365.             dir_util.remove_tree(base_dir, dry_run = self.dry_run)
  366.         
  367.  
  368.     
  369.     def get_archive_files(self):
  370.         """Return the list of archive files created when the command
  371.         was run, or None if the command hasn't run yet.
  372.         """
  373.         return self.archive_files
  374.  
  375.  
  376.